// Generated from Cobol.g4 by ANTLR 4.13.2
package ling.learn.antlr.cobol.gen;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue", "this-escape"})
public class CobolParser extends Parser {
	static { RuntimeMetaData.checkVersion("4.13.2", RuntimeMetaData.VERSION); }

	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		KW_CORR=1, KW_CORRESPONDING=2, KW_EXTERNAL=3, KW_FD=4, KW_IS=5, KW_MOVE=6, 
		KW_SD=7, KW_TO=8, OP_NOT_EQUAL2=9, OP_DOLLAR=10, OP_AMBER=11, OP_LPAREN=12, 
		OP_LBRACK2=13, OP_RPAREN=14, OP_STAR=15, OP_PLUS=16, OP_COMMA=17, OP_MINUS=18, 
		OP_DOT=19, OP_RBRACK2=20, OP_SLASH=21, OP_COLON=22, OP_ASSIGN=23, OP_SEMI=24, 
		OP_LT=25, OP_LE=26, OP_NOT_EQUAL1=27, OP_EQUAL=28, OP_GT=29, OP_GE=30, 
		OP_HELP=31, OP_LBRACK=32, OP_YEN=33, OP_RBRACK=34, OP_LCURLY=35, OP_OR=36, 
		OP_RCURLY=37, OP_NOT=38, StringLiteral=39, DbcsLiteral=40, Utf8Literal=41, 
		HexNumber=42, NullTerminated=43, IntegerLiteral=44, DecimalLiteral=45, 
		Identifier=46, EOL=47, WS=48, UnicodeBOM=49;
	public static final int
		RULE_file = 0, RULE_ruleLine = 1, RULE_fdStmt = 2, RULE_moveStmt = 3, 
		RULE_ws_move_destination = 4, RULE_ws_move_origination = 5, RULE_ws_文字列 = 6, 
		RULE_wd_ﾌｧｲﾙ名 = 7, RULE_line = 8, RULE_wordList = 9, RULE_word = 10, RULE_keyword = 11, 
		RULE_operator = 12, RULE_literal = 13, RULE_numericLiteral = 14, RULE_nonnumericLiteral = 15;
	private static String[] makeRuleNames() {
		return new String[] {
			"file", "ruleLine", "fdStmt", "moveStmt", "ws_move_destination", "ws_move_origination", 
			"ws_文字列", "wd_ﾌｧｲﾙ名", "line", "wordList", "word", "keyword", "operator", 
			"literal", "numericLiteral", "nonnumericLiteral"
		};
	}
	public static final String[] ruleNames = makeRuleNames();

	private static String[] makeLiteralNames() {
		return new String[] {
			null, "'CORR'", "'CORRESPONDING'", "'EXTERNAL'", "'FD'", "'IS'", "'MOVE'", 
			"'SD'", "'TO'", "'!='", "'$'", "'&'", "'('", "'(.'", "')'", "'*'", "'+'", 
			"','", "'-'", "'.'", "'.)'", "'/'", "':'", "':='", "';'", "'<'", "'<='", 
			"'<>'", "'='", "'>'", "'>='", "'?'", "'['", "'\\'", "']'", "'{'", "'|'", 
			"'}'", "'~'", null, null, null, null, null, null, null, null, null, null, 
			"'\\uFEFF'"
		};
	}
	private static final String[] _LITERAL_NAMES = makeLiteralNames();
	private static String[] makeSymbolicNames() {
		return new String[] {
			null, "KW_CORR", "KW_CORRESPONDING", "KW_EXTERNAL", "KW_FD", "KW_IS", 
			"KW_MOVE", "KW_SD", "KW_TO", "OP_NOT_EQUAL2", "OP_DOLLAR", "OP_AMBER", 
			"OP_LPAREN", "OP_LBRACK2", "OP_RPAREN", "OP_STAR", "OP_PLUS", "OP_COMMA", 
			"OP_MINUS", "OP_DOT", "OP_RBRACK2", "OP_SLASH", "OP_COLON", "OP_ASSIGN", 
			"OP_SEMI", "OP_LT", "OP_LE", "OP_NOT_EQUAL1", "OP_EQUAL", "OP_GT", "OP_GE", 
			"OP_HELP", "OP_LBRACK", "OP_YEN", "OP_RBRACK", "OP_LCURLY", "OP_OR", 
			"OP_RCURLY", "OP_NOT", "StringLiteral", "DbcsLiteral", "Utf8Literal", 
			"HexNumber", "NullTerminated", "IntegerLiteral", "DecimalLiteral", "Identifier", 
			"EOL", "WS", "UnicodeBOM"
		};
	}
	private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);

	/**
	 * @deprecated Use {@link #VOCABULARY} instead.
	 */
	@Deprecated
	public static final String[] tokenNames;
	static {
		tokenNames = new String[_SYMBOLIC_NAMES.length];
		for (int i = 0; i < tokenNames.length; i++) {
			tokenNames[i] = VOCABULARY.getLiteralName(i);
			if (tokenNames[i] == null) {
				tokenNames[i] = VOCABULARY.getSymbolicName(i);
			}

			if (tokenNames[i] == null) {
				tokenNames[i] = "<INVALID>";
			}
		}
	}

	@Override
	@Deprecated
	public String[] getTokenNames() {
		return tokenNames;
	}

	@Override

	public Vocabulary getVocabulary() {
		return VOCABULARY;
	}

	@Override
	public String getGrammarFileName() { return "Cobol.g4"; }

	@Override
	public String[] getRuleNames() { return ruleNames; }

	@Override
	public String getSerializedATN() { return _serializedATN; }

	@Override
	public ATN getATN() { return _ATN; }

	public CobolParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}

	@SuppressWarnings("CheckReturnValue")
	public static class FileContext extends ParserRuleContext {
		public TerminalNode EOF() { return getToken(CobolParser.EOF, 0); }
		public List<RuleLineContext> ruleLine() {
			return getRuleContexts(RuleLineContext.class);
		}
		public RuleLineContext ruleLine(int i) {
			return getRuleContext(RuleLineContext.class,i);
		}
		public List<LineContext> line() {
			return getRuleContexts(LineContext.class);
		}
		public LineContext line(int i) {
			return getRuleContext(LineContext.class,i);
		}
		public FileContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_file; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).enterFile(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).exitFile(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CobolVisitor ) return ((CobolVisitor<? extends T>)visitor).visitFile(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FileContext file() throws RecognitionException {
		FileContext _localctx = new FileContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_file);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(36);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 140737488355326L) != 0)) {
				{
				setState(34);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
				case 1:
					{
					setState(32);
					ruleLine();
					}
					break;
				case 2:
					{
					setState(33);
					line();
					}
					break;
				}
				}
				setState(38);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(39);
			match(EOF);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class RuleLineContext extends ParserRuleContext {
		public FdStmtContext fdStmt() {
			return getRuleContext(FdStmtContext.class,0);
		}
		public MoveStmtContext moveStmt() {
			return getRuleContext(MoveStmtContext.class,0);
		}
		public RuleLineContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ruleLine; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).enterRuleLine(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).exitRuleLine(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CobolVisitor ) return ((CobolVisitor<? extends T>)visitor).visitRuleLine(this);
			else return visitor.visitChildren(this);
		}
	}

	public final RuleLineContext ruleLine() throws RecognitionException {
		RuleLineContext _localctx = new RuleLineContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_ruleLine);
		try {
			setState(43);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case KW_FD:
			case KW_SD:
				enterOuterAlt(_localctx, 1);
				{
				setState(41);
				fdStmt();
				}
				break;
			case KW_MOVE:
				enterOuterAlt(_localctx, 2);
				{
				setState(42);
				moveStmt();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class FdStmtContext extends ParserRuleContext {
		public Wd_ﾌｧｲﾙ名Context wd_ﾌｧｲﾙ名() {
			return getRuleContext(Wd_ﾌｧｲﾙ名Context.class,0);
		}
		public TerminalNode EOL() { return getToken(CobolParser.EOL, 0); }
		public TerminalNode KW_FD() { return getToken(CobolParser.KW_FD, 0); }
		public TerminalNode KW_SD() { return getToken(CobolParser.KW_SD, 0); }
		public TerminalNode KW_EXTERNAL() { return getToken(CobolParser.KW_EXTERNAL, 0); }
		public Ws_文字列Context ws_文字列() {
			return getRuleContext(Ws_文字列Context.class,0);
		}
		public TerminalNode OP_DOT() { return getToken(CobolParser.OP_DOT, 0); }
		public TerminalNode OP_COMMA() { return getToken(CobolParser.OP_COMMA, 0); }
		public TerminalNode OP_SEMI() { return getToken(CobolParser.OP_SEMI, 0); }
		public TerminalNode KW_IS() { return getToken(CobolParser.KW_IS, 0); }
		public FdStmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_fdStmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).enterFdStmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).exitFdStmt(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CobolVisitor ) return ((CobolVisitor<? extends T>)visitor).visitFdStmt(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FdStmtContext fdStmt() throws RecognitionException {
		FdStmtContext _localctx = new FdStmtContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_fdStmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(45);
			_la = _input.LA(1);
			if ( !(_la==KW_FD || _la==KW_SD) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			setState(47);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
			case 1:
				{
				setState(46);
				_la = _input.LA(1);
				if ( !(_la==OP_COMMA || _la==OP_SEMI) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
				break;
			}
			setState(49);
			wd_ﾌｧｲﾙ名();
			setState(55);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
			case 1:
				{
				setState(51);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==KW_IS) {
					{
					setState(50);
					match(KW_IS);
					}
				}

				setState(53);
				match(KW_EXTERNAL);
				}
				break;
			case 2:
				{
				setState(54);
				ws_文字列();
				}
				break;
			}
			setState(58);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==OP_DOT) {
				{
				setState(57);
				match(OP_DOT);
				}
			}

			setState(60);
			match(EOL);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class MoveStmtContext extends ParserRuleContext {
		public TerminalNode KW_MOVE() { return getToken(CobolParser.KW_MOVE, 0); }
		public Ws_move_originationContext ws_move_origination() {
			return getRuleContext(Ws_move_originationContext.class,0);
		}
		public TerminalNode KW_TO() { return getToken(CobolParser.KW_TO, 0); }
		public Ws_move_destinationContext ws_move_destination() {
			return getRuleContext(Ws_move_destinationContext.class,0);
		}
		public TerminalNode EOL() { return getToken(CobolParser.EOL, 0); }
		public TerminalNode OP_DOT() { return getToken(CobolParser.OP_DOT, 0); }
		public TerminalNode KW_CORR() { return getToken(CobolParser.KW_CORR, 0); }
		public TerminalNode KW_CORRESPONDING() { return getToken(CobolParser.KW_CORRESPONDING, 0); }
		public MoveStmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_moveStmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).enterMoveStmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).exitMoveStmt(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CobolVisitor ) return ((CobolVisitor<? extends T>)visitor).visitMoveStmt(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MoveStmtContext moveStmt() throws RecognitionException {
		MoveStmtContext _localctx = new MoveStmtContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_moveStmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(62);
			match(KW_MOVE);
			setState(64);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
			case 1:
				{
				setState(63);
				_la = _input.LA(1);
				if ( !(_la==KW_CORR || _la==KW_CORRESPONDING) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
				break;
			}
			setState(66);
			ws_move_origination();
			setState(67);
			match(KW_TO);
			setState(68);
			ws_move_destination();
			setState(70);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==OP_DOT) {
				{
				setState(69);
				match(OP_DOT);
				}
			}

			setState(72);
			match(EOL);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Ws_move_destinationContext extends ParserRuleContext {
		public WordListContext wordList() {
			return getRuleContext(WordListContext.class,0);
		}
		public Ws_move_destinationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ws_move_destination; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).enterWs_move_destination(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).exitWs_move_destination(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CobolVisitor ) return ((CobolVisitor<? extends T>)visitor).visitWs_move_destination(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Ws_move_destinationContext ws_move_destination() throws RecognitionException {
		Ws_move_destinationContext _localctx = new Ws_move_destinationContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_ws_move_destination);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(74);
			wordList();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Ws_move_originationContext extends ParserRuleContext {
		public WordListContext wordList() {
			return getRuleContext(WordListContext.class,0);
		}
		public Ws_move_originationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ws_move_origination; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).enterWs_move_origination(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).exitWs_move_origination(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CobolVisitor ) return ((CobolVisitor<? extends T>)visitor).visitWs_move_origination(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Ws_move_originationContext ws_move_origination() throws RecognitionException {
		Ws_move_originationContext _localctx = new Ws_move_originationContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_ws_move_origination);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(76);
			wordList();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Ws_文字列Context extends ParserRuleContext {
		public WordListContext wordList() {
			return getRuleContext(WordListContext.class,0);
		}
		public Ws_文字列Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ws_文字列; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).enterWs_文字列(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).exitWs_文字列(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CobolVisitor ) return ((CobolVisitor<? extends T>)visitor).visitWs_文字列(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Ws_文字列Context ws_文字列() throws RecognitionException {
		Ws_文字列Context _localctx = new Ws_文字列Context(_ctx, getState());
		enterRule(_localctx, 12, RULE_ws_文字列);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(78);
			wordList();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Wd_ﾌｧｲﾙ名Context extends ParserRuleContext {
		public WordContext word() {
			return getRuleContext(WordContext.class,0);
		}
		public Wd_ﾌｧｲﾙ名Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_wd_ﾌｧｲﾙ名; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).enterWd_ﾌｧｲﾙ名(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).exitWd_ﾌｧｲﾙ名(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CobolVisitor ) return ((CobolVisitor<? extends T>)visitor).visitWd_ﾌｧｲﾙ名(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Wd_ﾌｧｲﾙ名Context wd_ﾌｧｲﾙ名() throws RecognitionException {
		Wd_ﾌｧｲﾙ名Context _localctx = new Wd_ﾌｧｲﾙ名Context(_ctx, getState());
		enterRule(_localctx, 14, RULE_wd_ﾌｧｲﾙ名);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(80);
			word();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class LineContext extends ParserRuleContext {
		public WordListContext wordList() {
			return getRuleContext(WordListContext.class,0);
		}
		public TerminalNode EOL() { return getToken(CobolParser.EOL, 0); }
		public LineContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_line; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).enterLine(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).exitLine(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CobolVisitor ) return ((CobolVisitor<? extends T>)visitor).visitLine(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LineContext line() throws RecognitionException {
		LineContext _localctx = new LineContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_line);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(82);
			wordList();
			setState(83);
			match(EOL);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class WordListContext extends ParserRuleContext {
		public List<WordContext> word() {
			return getRuleContexts(WordContext.class);
		}
		public WordContext word(int i) {
			return getRuleContext(WordContext.class,i);
		}
		public WordListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_wordList; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).enterWordList(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).exitWordList(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CobolVisitor ) return ((CobolVisitor<? extends T>)visitor).visitWordList(this);
			else return visitor.visitChildren(this);
		}
	}

	public final WordListContext wordList() throws RecognitionException {
		WordListContext _localctx = new WordListContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_wordList);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(86); 
			_errHandler.sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					{
					setState(85);
					word();
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(88); 
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,9,_ctx);
			} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class WordContext extends ParserRuleContext {
		public OperatorContext operator() {
			return getRuleContext(OperatorContext.class,0);
		}
		public LiteralContext literal() {
			return getRuleContext(LiteralContext.class,0);
		}
		public KeywordContext keyword() {
			return getRuleContext(KeywordContext.class,0);
		}
		public TerminalNode Identifier() { return getToken(CobolParser.Identifier, 0); }
		public WordContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_word; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).enterWord(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).exitWord(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CobolVisitor ) return ((CobolVisitor<? extends T>)visitor).visitWord(this);
			else return visitor.visitChildren(this);
		}
	}

	public final WordContext word() throws RecognitionException {
		WordContext _localctx = new WordContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_word);
		try {
			setState(94);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case OP_NOT_EQUAL2:
			case OP_DOLLAR:
			case OP_AMBER:
			case OP_LPAREN:
			case OP_LBRACK2:
			case OP_RPAREN:
			case OP_STAR:
			case OP_PLUS:
			case OP_COMMA:
			case OP_MINUS:
			case OP_DOT:
			case OP_RBRACK2:
			case OP_SLASH:
			case OP_COLON:
			case OP_ASSIGN:
			case OP_SEMI:
			case OP_LT:
			case OP_LE:
			case OP_NOT_EQUAL1:
			case OP_EQUAL:
			case OP_GT:
			case OP_GE:
			case OP_HELP:
			case OP_LBRACK:
			case OP_YEN:
			case OP_RBRACK:
			case OP_LCURLY:
			case OP_OR:
			case OP_RCURLY:
			case OP_NOT:
				enterOuterAlt(_localctx, 1);
				{
				setState(90);
				operator();
				}
				break;
			case StringLiteral:
			case DbcsLiteral:
			case Utf8Literal:
			case HexNumber:
			case NullTerminated:
			case IntegerLiteral:
			case DecimalLiteral:
				enterOuterAlt(_localctx, 2);
				{
				setState(91);
				literal();
				}
				break;
			case KW_CORR:
			case KW_CORRESPONDING:
			case KW_EXTERNAL:
			case KW_FD:
			case KW_IS:
			case KW_MOVE:
			case KW_SD:
			case KW_TO:
				enterOuterAlt(_localctx, 3);
				{
				setState(92);
				keyword();
				}
				break;
			case Identifier:
				enterOuterAlt(_localctx, 4);
				{
				setState(93);
				match(Identifier);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class KeywordContext extends ParserRuleContext {
		public TerminalNode KW_CORR() { return getToken(CobolParser.KW_CORR, 0); }
		public TerminalNode KW_CORRESPONDING() { return getToken(CobolParser.KW_CORRESPONDING, 0); }
		public TerminalNode KW_EXTERNAL() { return getToken(CobolParser.KW_EXTERNAL, 0); }
		public TerminalNode KW_FD() { return getToken(CobolParser.KW_FD, 0); }
		public TerminalNode KW_IS() { return getToken(CobolParser.KW_IS, 0); }
		public TerminalNode KW_MOVE() { return getToken(CobolParser.KW_MOVE, 0); }
		public TerminalNode KW_SD() { return getToken(CobolParser.KW_SD, 0); }
		public TerminalNode KW_TO() { return getToken(CobolParser.KW_TO, 0); }
		public KeywordContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_keyword; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).enterKeyword(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).exitKeyword(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CobolVisitor ) return ((CobolVisitor<? extends T>)visitor).visitKeyword(this);
			else return visitor.visitChildren(this);
		}
	}

	public final KeywordContext keyword() throws RecognitionException {
		KeywordContext _localctx = new KeywordContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_keyword);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(96);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 510L) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class OperatorContext extends ParserRuleContext {
		public TerminalNode OP_NOT_EQUAL2() { return getToken(CobolParser.OP_NOT_EQUAL2, 0); }
		public TerminalNode OP_DOLLAR() { return getToken(CobolParser.OP_DOLLAR, 0); }
		public TerminalNode OP_AMBER() { return getToken(CobolParser.OP_AMBER, 0); }
		public TerminalNode OP_LPAREN() { return getToken(CobolParser.OP_LPAREN, 0); }
		public TerminalNode OP_LBRACK2() { return getToken(CobolParser.OP_LBRACK2, 0); }
		public TerminalNode OP_RPAREN() { return getToken(CobolParser.OP_RPAREN, 0); }
		public TerminalNode OP_STAR() { return getToken(CobolParser.OP_STAR, 0); }
		public TerminalNode OP_PLUS() { return getToken(CobolParser.OP_PLUS, 0); }
		public TerminalNode OP_COMMA() { return getToken(CobolParser.OP_COMMA, 0); }
		public TerminalNode OP_MINUS() { return getToken(CobolParser.OP_MINUS, 0); }
		public TerminalNode OP_DOT() { return getToken(CobolParser.OP_DOT, 0); }
		public TerminalNode OP_RBRACK2() { return getToken(CobolParser.OP_RBRACK2, 0); }
		public TerminalNode OP_SLASH() { return getToken(CobolParser.OP_SLASH, 0); }
		public TerminalNode OP_COLON() { return getToken(CobolParser.OP_COLON, 0); }
		public TerminalNode OP_ASSIGN() { return getToken(CobolParser.OP_ASSIGN, 0); }
		public TerminalNode OP_SEMI() { return getToken(CobolParser.OP_SEMI, 0); }
		public TerminalNode OP_LT() { return getToken(CobolParser.OP_LT, 0); }
		public TerminalNode OP_LE() { return getToken(CobolParser.OP_LE, 0); }
		public TerminalNode OP_NOT_EQUAL1() { return getToken(CobolParser.OP_NOT_EQUAL1, 0); }
		public TerminalNode OP_EQUAL() { return getToken(CobolParser.OP_EQUAL, 0); }
		public TerminalNode OP_GT() { return getToken(CobolParser.OP_GT, 0); }
		public TerminalNode OP_GE() { return getToken(CobolParser.OP_GE, 0); }
		public TerminalNode OP_HELP() { return getToken(CobolParser.OP_HELP, 0); }
		public TerminalNode OP_LBRACK() { return getToken(CobolParser.OP_LBRACK, 0); }
		public TerminalNode OP_YEN() { return getToken(CobolParser.OP_YEN, 0); }
		public TerminalNode OP_RBRACK() { return getToken(CobolParser.OP_RBRACK, 0); }
		public TerminalNode OP_LCURLY() { return getToken(CobolParser.OP_LCURLY, 0); }
		public TerminalNode OP_OR() { return getToken(CobolParser.OP_OR, 0); }
		public TerminalNode OP_RCURLY() { return getToken(CobolParser.OP_RCURLY, 0); }
		public TerminalNode OP_NOT() { return getToken(CobolParser.OP_NOT, 0); }
		public OperatorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_operator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).enterOperator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).exitOperator(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CobolVisitor ) return ((CobolVisitor<? extends T>)visitor).visitOperator(this);
			else return visitor.visitChildren(this);
		}
	}

	public final OperatorContext operator() throws RecognitionException {
		OperatorContext _localctx = new OperatorContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_operator);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(98);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 549755813376L) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class LiteralContext extends ParserRuleContext {
		public NumericLiteralContext numericLiteral() {
			return getRuleContext(NumericLiteralContext.class,0);
		}
		public NonnumericLiteralContext nonnumericLiteral() {
			return getRuleContext(NonnumericLiteralContext.class,0);
		}
		public LiteralContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_literal; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).enterLiteral(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).exitLiteral(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CobolVisitor ) return ((CobolVisitor<? extends T>)visitor).visitLiteral(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LiteralContext literal() throws RecognitionException {
		LiteralContext _localctx = new LiteralContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_literal);
		try {
			setState(102);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case IntegerLiteral:
			case DecimalLiteral:
				enterOuterAlt(_localctx, 1);
				{
				setState(100);
				numericLiteral();
				}
				break;
			case StringLiteral:
			case DbcsLiteral:
			case Utf8Literal:
			case HexNumber:
			case NullTerminated:
				enterOuterAlt(_localctx, 2);
				{
				setState(101);
				nonnumericLiteral();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class NumericLiteralContext extends ParserRuleContext {
		public TerminalNode DecimalLiteral() { return getToken(CobolParser.DecimalLiteral, 0); }
		public TerminalNode IntegerLiteral() { return getToken(CobolParser.IntegerLiteral, 0); }
		public NumericLiteralContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_numericLiteral; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).enterNumericLiteral(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).exitNumericLiteral(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CobolVisitor ) return ((CobolVisitor<? extends T>)visitor).visitNumericLiteral(this);
			else return visitor.visitChildren(this);
		}
	}

	public final NumericLiteralContext numericLiteral() throws RecognitionException {
		NumericLiteralContext _localctx = new NumericLiteralContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_numericLiteral);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(104);
			_la = _input.LA(1);
			if ( !(_la==IntegerLiteral || _la==DecimalLiteral) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class NonnumericLiteralContext extends ParserRuleContext {
		public TerminalNode StringLiteral() { return getToken(CobolParser.StringLiteral, 0); }
		public TerminalNode DbcsLiteral() { return getToken(CobolParser.DbcsLiteral, 0); }
		public TerminalNode Utf8Literal() { return getToken(CobolParser.Utf8Literal, 0); }
		public TerminalNode HexNumber() { return getToken(CobolParser.HexNumber, 0); }
		public TerminalNode NullTerminated() { return getToken(CobolParser.NullTerminated, 0); }
		public NonnumericLiteralContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_nonnumericLiteral; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).enterNonnumericLiteral(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CobolListener ) ((CobolListener)listener).exitNonnumericLiteral(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CobolVisitor ) return ((CobolVisitor<? extends T>)visitor).visitNonnumericLiteral(this);
			else return visitor.visitChildren(this);
		}
	}

	public final NonnumericLiteralContext nonnumericLiteral() throws RecognitionException {
		NonnumericLiteralContext _localctx = new NonnumericLiteralContext(_ctx, getState());
		enterRule(_localctx, 30, RULE_nonnumericLiteral);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(106);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 17042430230528L) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static final String _serializedATN =
		"\u0004\u00011m\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001\u0002\u0002"+
		"\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004\u0002\u0005"+
		"\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007\u0002\b\u0007"+
		"\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b\u0002\f\u0007"+
		"\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007\u000f\u0001"+
		"\u0000\u0001\u0000\u0005\u0000#\b\u0000\n\u0000\f\u0000&\t\u0000\u0001"+
		"\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0003\u0001,\b\u0001\u0001"+
		"\u0002\u0001\u0002\u0003\u00020\b\u0002\u0001\u0002\u0001\u0002\u0003"+
		"\u00024\b\u0002\u0001\u0002\u0001\u0002\u0003\u00028\b\u0002\u0001\u0002"+
		"\u0003\u0002;\b\u0002\u0001\u0002\u0001\u0002\u0001\u0003\u0001\u0003"+
		"\u0003\u0003A\b\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003"+
		"\u0003\u0003G\b\u0003\u0001\u0003\u0001\u0003\u0001\u0004\u0001\u0004"+
		"\u0001\u0005\u0001\u0005\u0001\u0006\u0001\u0006\u0001\u0007\u0001\u0007"+
		"\u0001\b\u0001\b\u0001\b\u0001\t\u0004\tW\b\t\u000b\t\f\tX\u0001\n\u0001"+
		"\n\u0001\n\u0001\n\u0003\n_\b\n\u0001\u000b\u0001\u000b\u0001\f\u0001"+
		"\f\u0001\r\u0001\r\u0003\rg\b\r\u0001\u000e\u0001\u000e\u0001\u000f\u0001"+
		"\u000f\u0001\u000f\u0000\u0000\u0010\u0000\u0002\u0004\u0006\b\n\f\u000e"+
		"\u0010\u0012\u0014\u0016\u0018\u001a\u001c\u001e\u0000\u0007\u0002\u0000"+
		"\u0004\u0004\u0007\u0007\u0002\u0000\u0011\u0011\u0018\u0018\u0001\u0000"+
		"\u0001\u0002\u0001\u0000\u0001\b\u0001\u0000\t&\u0001\u0000,-\u0001\u0000"+
		"\'+j\u0000$\u0001\u0000\u0000\u0000\u0002+\u0001\u0000\u0000\u0000\u0004"+
		"-\u0001\u0000\u0000\u0000\u0006>\u0001\u0000\u0000\u0000\bJ\u0001\u0000"+
		"\u0000\u0000\nL\u0001\u0000\u0000\u0000\fN\u0001\u0000\u0000\u0000\u000e"+
		"P\u0001\u0000\u0000\u0000\u0010R\u0001\u0000\u0000\u0000\u0012V\u0001"+
		"\u0000\u0000\u0000\u0014^\u0001\u0000\u0000\u0000\u0016`\u0001\u0000\u0000"+
		"\u0000\u0018b\u0001\u0000\u0000\u0000\u001af\u0001\u0000\u0000\u0000\u001c"+
		"h\u0001\u0000\u0000\u0000\u001ej\u0001\u0000\u0000\u0000 #\u0003\u0002"+
		"\u0001\u0000!#\u0003\u0010\b\u0000\" \u0001\u0000\u0000\u0000\"!\u0001"+
		"\u0000\u0000\u0000#&\u0001\u0000\u0000\u0000$\"\u0001\u0000\u0000\u0000"+
		"$%\u0001\u0000\u0000\u0000%\'\u0001\u0000\u0000\u0000&$\u0001\u0000\u0000"+
		"\u0000\'(\u0005\u0000\u0000\u0001(\u0001\u0001\u0000\u0000\u0000),\u0003"+
		"\u0004\u0002\u0000*,\u0003\u0006\u0003\u0000+)\u0001\u0000\u0000\u0000"+
		"+*\u0001\u0000\u0000\u0000,\u0003\u0001\u0000\u0000\u0000-/\u0007\u0000"+
		"\u0000\u0000.0\u0007\u0001\u0000\u0000/.\u0001\u0000\u0000\u0000/0\u0001"+
		"\u0000\u0000\u000001\u0001\u0000\u0000\u000017\u0003\u000e\u0007\u0000"+
		"24\u0005\u0005\u0000\u000032\u0001\u0000\u0000\u000034\u0001\u0000\u0000"+
		"\u000045\u0001\u0000\u0000\u000058\u0005\u0003\u0000\u000068\u0003\f\u0006"+
		"\u000073\u0001\u0000\u0000\u000076\u0001\u0000\u0000\u00008:\u0001\u0000"+
		"\u0000\u00009;\u0005\u0013\u0000\u0000:9\u0001\u0000\u0000\u0000:;\u0001"+
		"\u0000\u0000\u0000;<\u0001\u0000\u0000\u0000<=\u0005/\u0000\u0000=\u0005"+
		"\u0001\u0000\u0000\u0000>@\u0005\u0006\u0000\u0000?A\u0007\u0002\u0000"+
		"\u0000@?\u0001\u0000\u0000\u0000@A\u0001\u0000\u0000\u0000AB\u0001\u0000"+
		"\u0000\u0000BC\u0003\n\u0005\u0000CD\u0005\b\u0000\u0000DF\u0003\b\u0004"+
		"\u0000EG\u0005\u0013\u0000\u0000FE\u0001\u0000\u0000\u0000FG\u0001\u0000"+
		"\u0000\u0000GH\u0001\u0000\u0000\u0000HI\u0005/\u0000\u0000I\u0007\u0001"+
		"\u0000\u0000\u0000JK\u0003\u0012\t\u0000K\t\u0001\u0000\u0000\u0000LM"+
		"\u0003\u0012\t\u0000M\u000b\u0001\u0000\u0000\u0000NO\u0003\u0012\t\u0000"+
		"O\r\u0001\u0000\u0000\u0000PQ\u0003\u0014\n\u0000Q\u000f\u0001\u0000\u0000"+
		"\u0000RS\u0003\u0012\t\u0000ST\u0005/\u0000\u0000T\u0011\u0001\u0000\u0000"+
		"\u0000UW\u0003\u0014\n\u0000VU\u0001\u0000\u0000\u0000WX\u0001\u0000\u0000"+
		"\u0000XV\u0001\u0000\u0000\u0000XY\u0001\u0000\u0000\u0000Y\u0013\u0001"+
		"\u0000\u0000\u0000Z_\u0003\u0018\f\u0000[_\u0003\u001a\r\u0000\\_\u0003"+
		"\u0016\u000b\u0000]_\u0005.\u0000\u0000^Z\u0001\u0000\u0000\u0000^[\u0001"+
		"\u0000\u0000\u0000^\\\u0001\u0000\u0000\u0000^]\u0001\u0000\u0000\u0000"+
		"_\u0015\u0001\u0000\u0000\u0000`a\u0007\u0003\u0000\u0000a\u0017\u0001"+
		"\u0000\u0000\u0000bc\u0007\u0004\u0000\u0000c\u0019\u0001\u0000\u0000"+
		"\u0000dg\u0003\u001c\u000e\u0000eg\u0003\u001e\u000f\u0000fd\u0001\u0000"+
		"\u0000\u0000fe\u0001\u0000\u0000\u0000g\u001b\u0001\u0000\u0000\u0000"+
		"hi\u0007\u0005\u0000\u0000i\u001d\u0001\u0000\u0000\u0000jk\u0007\u0006"+
		"\u0000\u0000k\u001f\u0001\u0000\u0000\u0000\f\"$+/37:@FX^f";
	public static final ATN _ATN =
		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
	static {
		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
		}
	}
}